{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Deterministic Policy Gradient (DDPG) with PyTorch\n",
    "\n",
    "In this notebook we will look at Deep Deterministic Policy Gradient (DDPG) algorithm using PyTorch. DDPG is a variation of Q-Learning with continuous action functions. When we have discrete functions, we learn Q-function of a  given state and all possible actions. We then pick the best action and Q-value using `max` over all values: Q(s,a), a is all possible actions. \n",
    "\n",
    "$$a^*(s) = arg \\underset{a}{max} Q^*(s,a)$$ \n",
    "\n",
    "However, when action is continuous, we cannot find the max so easily. It becomes an optimization problem with significant costs as we have to find the max at every step.\n",
    "\n",
    "In DDPG we learn two networks, one is a policy network which takes state as input and learns to output the policy/action. Another network learns the Q function. However, unlike Q-learning of past, it takes state and actions as inputs and produces Q-value as output. \n",
    "\n",
    "DDPG is an off-policy learning like Q-Learning, so we use ReplayBuffer to collect the transitions and iterate over it a batch to do gradient update for the policy(Actor) and Q-value(Critic) networks. \n",
    "\n",
    "Like Q-Learning, we also use target networks, both for policy as well as Q-value. The target networks are updated using polyak averaging. \n",
    "\n",
    "\n",
    "Click here to access the paper which proposed DDPG: https://arxiv.org/pdf/1509.02971.pdf\n",
    "\n",
    "The complete Algorithm is as given below:\n",
    "\n",
    "***\n",
    "**Deep Deterministic Policy Gradient**\n",
    "***\n",
    " \n",
    "1. Input initial policy parameters $\\theta$,  Q-function parameters $\\phi$, empty replay buffer D\n",
    "\n",
    "2. Set target parameters equal to online parameters $\\theta_{targ} \\leftarrow \\theta$ and $\\phi_{targ} \\leftarrow \\phi$\n",
    "\n",
    "3. **repeat**\n",
    "\n",
    "4. Observe state s and select action $a = clip(\\mu_\\theta(s)+\\epsilon, a_{Low}, a_{High}), \\text{where  } \\epsilon \\sim N$\n",
    "\n",
    "5. Execute a in environment and observe next state s', reward r, and done signal d\n",
    "\n",
    "6. Store `(s,a,r,s',d)` in Replay Buffer D\n",
    "\n",
    "7. if `s'` is terminal state, reset the environment\n",
    "\n",
    "8. if it's time to update **then**:\n",
    "\n",
    "9. &emsp;&emsp;for as many updates as required:\n",
    "\n",
    "10. &emsp;&emsp;&emsp;&emsp;Sample a batch B={`(s,a,r,s',d)`} from replay Buffer D:\n",
    "\n",
    "11. &emsp;&emsp;&emsp;&emsp;Compute targets: $$y(r,s',d) = r + \\gamma(1-d)Q_{targ}(s',\\mu_{\\theta_{targ}}(s'))$$\n",
    "\n",
    "12. &emsp;&emsp;&emsp;&emsp;Update Q function with one step gradient descent on $$\\phi$: $\\nabla_\\phi \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_\\phi(s,a) - y(r,s',d))^2$$\n",
    "\n",
    "13. &emsp;&emsp;&emsp;&emsp;Update Policy with one step gradient Ascent on $\\theta$: $$\\nabla_\\theta \\frac{1}{|B|} \\sum_{s \\in B} Q_\\phi(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "14. Update target networks using polyak averaging: $$\\phi_{targ} \\leftarrow \\rho\\phi_{targ} + (1-\\rho)\\phi$$  $$\\theta_{targ} \\leftarrow \\rho\\theta_{targ} + (1-\\rho)\\theta$$\n",
    "***\n",
    "\n",
    "\n",
    "#### Key Features of DDPG\n",
    "1. DDPG is an off-policy algorithm.\n",
    "2. DDPG can only be used for environments with continuous action spaces.\n",
    "3. DDPG can be thought of as being deep Q-learning for continuous action spaces.\n",
    "\n",
    "\n",
    "#### Our Implementation\n",
    "This notebook follows the code found in OpenAI's [Spinning Up Library](https://spinningup.openai.com/en/latest/algorithms/ddpg.html). In this notebook we have broken the code into separate code cells with required explanations. Also some of the implementations like ReplayBuffer have been borrowed from our past notebooks to provide continuity. Further some codes like building of networks have been simplified resulting in easier to understand but more verbose code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "\n",
    "from copy import deepcopy\n",
    "import gym\n",
    "\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - Pendulum\n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are continuous. We will build it on `Pendulum-v0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State shape: (3,)\n",
      "Action shape: (1,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, action_shape = env.observation_space.shape, env.action_space.shape\n",
    "print('State shape: {}'.format(state_shape))\n",
    "print('Action shape: {}'.format(action_shape))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Policy network (Actor)\n",
    "It is a simple 2 hidden layer network which takes state as input and produces action making sure that action values are within the allowed range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActor(nn.Module):\n",
    "    def __init__(self, state_dim, act_dim, act_limit):\n",
    "        super().__init__()\n",
    "        self.act_limit = act_limit\n",
    "        self.fc1 = nn.Linear(state_dim, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.actor = nn.Linear(256, act_dim)\n",
    "    \n",
    "    def forward(self, s):\n",
    "        x = self.fc1(s)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.actor(x)\n",
    "        x = torch.tanh(x)  # to output in range(-1,1)\n",
    "        x = self.act_limit * x\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Q-network network (Critic)\n",
    "It is a simple 2 hidden layer network which takes state and action as input and produces Q-value as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPQFunction(nn.Module):\n",
    "    def __init__(self, state_dim, act_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(state_dim+act_dim, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.Q = nn.Linear(256, 1)\n",
    "    \n",
    "    def forward(self, s, a):\n",
    "        x = torch.cat([s,a], dim=-1)\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        q = self.Q(x)\n",
    "        return torch.squeeze(q, -1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine Actor and Critic into a single model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActorCritic(nn.Module):\n",
    "    def __init__(self, observation_space, action_space):\n",
    "        super().__init__()\n",
    "        self.state_dim = observation_space.shape[0]\n",
    "        self.act_dim = action_space.shape[0]\n",
    "        self.act_limit = action_space.high[0]\n",
    "        \n",
    "        #build Q and policy functions\n",
    "        self.q = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.policy = MLPActor(self.state_dim, self.act_dim, self.act_limit)\n",
    "        \n",
    "    def act(self, state):\n",
    "        with torch.no_grad():\n",
    "            return self.policy(state).numpy()\n",
    "\n",
    "    def get_action(self, s, noise_scale):\n",
    "        a = self.act(torch.as_tensor(s, dtype=torch.float32))\n",
    "        a += noise_scale * np.random.randn(self.act_dim)\n",
    "        return np.clip(a, -self.act_limit, self.act_limit)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size=1e6):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "            self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size=32):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-loss\n",
    "\n",
    "Compute Q-loss as per equation:\n",
    "    \n",
    "$$y(r,s',d) = r + \\gamma(1-d)Q_{targ}(s',\\mu_{\\theta_{targ}}(s'))$$\n",
    "\n",
    "$$Q_{Loss} =  \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_\\phi(s,a) - y(r,s',d))^2$$\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99):\n",
    "    \n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, dtype=torch.float)\n",
    "    rewards = torch.tensor(rewards, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),dtype=torch.float)\n",
    "    \n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent.q(states, actions)\n",
    "    \n",
    "    # Bellman backup for Q function\n",
    "    with torch.no_grad():\n",
    "        q__next_state_values = target_network.q(next_states, target_network.policy(next_states))\n",
    "        target = rewards + gamma * (1 - done_flags) * q__next_state_values\n",
    "\n",
    "    # MSE loss against Bellman backup\n",
    "    loss_q = ((predicted_qvalues - target)**2).mean()\n",
    "\n",
    "    return loss_q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy-Loss\n",
    "\n",
    "Compute Policy Loss as per equation:\n",
    "    \n",
    "$$ Policy_{Loss} = - \\frac{1}{|B|} \\sum_{s \\in B} Q_\\phi(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "Please note the `-` sign. We need to do gradient ascent but PyTorch does gradient descent. We convert the ascent to descent using a -ve sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_policy_loss(agent, states):\n",
    "    \n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, dtype=torch.float)\n",
    "    \n",
    "    predicted_qvalues = agent.q(states, agent.policy(states))\n",
    "    \n",
    "    loss_policy = - predicted_qvalues.mean()\n",
    "    \n",
    "    return loss_policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One step gradient Descent on both Policy(Actor) and Q-value(Critic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_step_update(agent, target_network, q_optimizer, policy_optimizer, \n",
    "                    states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, polyak=0.995):\n",
    "    \n",
    "    #one step gradient for q-values\n",
    "    q_optimizer.zero_grad()\n",
    "    loss_q = compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma)\n",
    "    loss_q.backward()\n",
    "    q_optimizer.step()\n",
    "    \n",
    "    \n",
    "    #Freeze Q-network\n",
    "    for params in agent.q.parameters():\n",
    "        params.requires_grad = False\n",
    "\n",
    "    #one setep gradient for policy network\n",
    "    policy_optimizer.zero_grad()\n",
    "    loss_policy = compute_policy_loss(agent, states)\n",
    "    loss_policy.backward()\n",
    "    policy_optimizer.step()\n",
    "    \n",
    "    #UnFreeze Q-network\n",
    "    for params in agent.q.parameters():\n",
    "        params.requires_grad = True\n",
    "        \n",
    "        \n",
    "    # update target networks with polyak averaging\n",
    "    with torch.no_grad():\n",
    "        for params, params_target in zip(agent.parameters(), target_network.parameters()):\n",
    "            params_target.data.mul_(polyak)\n",
    "            params_target.data.add_((1-polyak)*params.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To Test performance of agent without any noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_agent(env, agent, num_test_episodes, max_ep_len):\n",
    "    ep_rets, ep_lens = [], []\n",
    "    for j in range(num_test_episodes):\n",
    "        state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "        while not(done or (ep_len == max_ep_len)):\n",
    "            # Take deterministic actions at test time (noise_scale=0)\n",
    "            state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "            ep_ret += reward\n",
    "            ep_len += 1\n",
    "        ep_rets.append(ep_ret)\n",
    "        ep_lens.append(ep_len)\n",
    "    return np.mean(ep_rets), np.mean(ep_lens)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DDPG Algorithm\n",
    "\n",
    "We pull all the pieces together to train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ddpg(env_fn, seed=0, \n",
    "         steps_per_epoch=4000, epochs=5, replay_size=int(1e6), gamma=0.99, \n",
    "         polyak=0.995, policy_lr=1e-3, q_lr=1e-3, batch_size=100, start_steps=10000, \n",
    "         update_after=1000, update_every=50, act_noise=0.1, num_test_episodes=10, \n",
    "         max_ep_len=1000):\n",
    "    \n",
    "    torch.manual_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    env, test_env = env_fn(), env_fn()\n",
    "    \n",
    "    ep_rets, ep_lens = [], []\n",
    "\n",
    "    state_dim = env.observation_space.shape\n",
    "    act_dim = env.action_space.shape[0]\n",
    "    \n",
    "    act_limit = env.action_space.high[0]\n",
    "    \n",
    "    agent = MLPActorCritic(env.observation_space, env.action_space)\n",
    "    target_network = deepcopy(agent)\n",
    "    \n",
    "    \n",
    "    # Freeze target networks with respect to optimizers (only update via polyak averaging)\n",
    "    for params in target_network.parameters():\n",
    "        params.requires_grad = False\n",
    "    \n",
    "    # Experience buffer\n",
    "    replay_buffer = ReplayBuffer(replay_size)\n",
    "    \n",
    "    #optimizers\n",
    "    q_optimizer = Adam(agent.q.parameters(), lr=q_lr)\n",
    "    policy_optimizer = Adam(agent.policy.parameters(), lr=policy_lr)\n",
    "    \n",
    "    total_steps = steps_per_epoch*epochs\n",
    "    state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "    \n",
    "    for t in range(total_steps):\n",
    "        if t > start_steps:\n",
    "            action = agent.get_action(state, act_noise)\n",
    "        else:\n",
    "            action = env.action_space.sample()\n",
    "            \n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "        \n",
    "        # Ignore the \"done\" signal if it comes from hitting the time\n",
    "        # horizon (that is, when it's an artificial terminal signal\n",
    "        # that isn't based on the agent's state)\n",
    "        done = False if ep_len==max_ep_len else done\n",
    "        \n",
    "        # Store experience to replay buffer\n",
    "        replay_buffer.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "        # End of trajectory handling\n",
    "        if done or (ep_len == max_ep_len):\n",
    "            ep_rets.append(ep_ret)\n",
    "            ep_lens.append(ep_len)\n",
    "            state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "        \n",
    "        # Update handling\n",
    "        if t >= update_after and t % update_every == 0:\n",
    "            for _ in range(update_every):\n",
    "                states, actions, rewards, next_states, done_flags = replay_buffer.sample(batch_size)\n",
    "                \n",
    "                one_step_update(\n",
    "                        agent, target_network, q_optimizer, policy_optimizer, \n",
    "                        states, actions, rewards, next_states, done_flags,\n",
    "                        gamma, polyak\n",
    "                )\n",
    "        \n",
    "        # End of epoch handling\n",
    "        if (t+1) % steps_per_epoch == 0:\n",
    "            epoch = (t+1) // steps_per_epoch\n",
    "            \n",
    "            avg_ret, avg_len = test_agent(test_env, agent, num_test_episodes, max_ep_len)\n",
    "            print(\"End of epoch: {:.0f}, Training Average Reward: {:.0f}, Training Average Length: {:.0f}\".format(epoch, np.mean(ep_rets), np.mean(ep_lens)))\n",
    "            print(\"End of epoch: {:.0f}, Test Average Reward: {:.0f}, Test Average Length: {:.0f}\".format(epoch, avg_ret, avg_len))\n",
    "            ep_rets, ep_lens = [], []\n",
    "    \n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -5933, Training Average Length: 1000\n",
      "End of epoch: 1, Test Average Reward: -425, Test Average Length: 1000\n",
      "End of epoch: 2, Training Average Reward: -5834, Training Average Length: 1000\n",
      "End of epoch: 2, Test Average Reward: -159, Test Average Length: 1000\n",
      "End of epoch: 3, Training Average Reward: -2744, Training Average Length: 1000\n",
      "End of epoch: 3, Test Average Reward: -164, Test Average Length: 1000\n",
      "End of epoch: 4, Training Average Reward: -215, Training Average Length: 1000\n",
      "End of epoch: 4, Test Average Reward: -143, Test Average Length: 1000\n",
      "End of epoch: 5, Training Average Reward: -206, Training Average Length: 1000\n",
      "End of epoch: 5, Test Average Reward: -168, Test Average Length: 1000\n"
     ]
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "agent = ddpg(lambda : make_env(env_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "    while not done:\n",
    "        # Take deterministic actions at test time (noise_scale=0)\n",
    "        state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "\n",
    "    print('Reward: {}'.format(ep_ret))\n",
    "    env.close()\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reward: -126.11195162992021\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/ddpg/pendulum'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train and evaluate performance on LunarLander Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -223, Training Average Length: 106\n",
      "End of epoch: 1, Test Average Reward: -139, Test Average Length: 194\n",
      "End of epoch: 2, Training Average Reward: -220, Training Average Length: 110\n",
      "End of epoch: 2, Test Average Reward: -173, Test Average Length: 263\n",
      "End of epoch: 3, Training Average Reward: -190, Training Average Length: 105\n",
      "End of epoch: 3, Test Average Reward: -250, Test Average Length: 71\n",
      "End of epoch: 4, Training Average Reward: -251, Training Average Length: 72\n",
      "End of epoch: 4, Test Average Reward: -309, Test Average Length: 76\n",
      "End of epoch: 5, Training Average Reward: -217, Training Average Length: 93\n",
      "End of epoch: 5, Test Average Reward: -230, Test Average Length: 382\n",
      "Reward: -212.02926666169338\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train\n",
    "env_name = 'LunarLanderContinuous-v2'\n",
    "agent1 = ddpg(lambda : make_env(env_name))\n",
    "\n",
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/ddpg/lunar'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent1, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
